/**
 * 应用初始化模块
 * 统一初始化所有错误处理和安全机制
 */

import globalErrorHandler from './globalErrorHandler.js'
import errorMonitoring from './errorMonitoring.js'
import lifecycleManager from './componentLifecycle.js'
import textUpdateSafe from './textUpdateSafe.js'

class AppInitializer {
  constructor() {
    this.isInitialized = false
    this.initStartTime = null
    this.initEndTime = null
  }

  /**
   * 初始化应用
   */
  async init() {
    if (this.isInitialized) {
      console.warn('应用已经初始化过了')
      return
    }

    this.initStartTime = Date.now()
    console.log('开始初始化应用安全机制...')

    try {
      // 1. 初始化错误监控系统
      console.log('1. 初始化错误监控系统')
      errorMonitoring.setEnabled(true)

      // 2. 初始化全局错误处理
      console.log('2. 初始化全局错误处理')
      globalErrorHandler.init()

      // 3. 设置应用级别的错误处理
      console.log('3. 设置应用级别的错误处理')
      this.setupAppErrorHandling()

      // 4. 初始化组件生命周期管理
      console.log('4. 初始化组件生命周期管理')
      // lifecycleManager 已经是单例，无需特殊初始化

      // 5. 设置文本更新安全机制
      console.log('5. 设置文本更新安全机制')
      // textUpdateSafe 已经是单例，无需特殊初始化

      // 6. 设置微信小程序特殊处理
      console.log('6. 设置微信小程序特殊处理')
      this.setupMiniProgramSpecific()

      // 7. 设置性能监控
      console.log('7. 设置性能监控')
      this.setupPerformanceMonitoring()

      // 8. 设置内存管理
      console.log('8. 设置内存管理')
      this.setupMemoryManagement()

      this.initEndTime = Date.now()
      this.isInitialized = true

      console.log(`应用安全机制初始化完成，耗时: ${this.initEndTime - this.initStartTime}ms`)

      // 记录初始化成功
      this.logInitSuccess()

    } catch (error) {
      console.error('应用初始化失败:', error)
      
      // 记录初始化失败
      errorMonitoring.logTextUpdateError('APP_INIT_ERROR', error, {
        initStartTime: this.initStartTime,
        failedAt: Date.now()
      })

      // 尝试降级初始化
      this.fallbackInit()
    }
  }

  /**
   * 设置应用级别的错误处理
   */
  setupAppErrorHandling() {
    // 添加应用特定的错误处理器
    globalErrorHandler.addErrorHandler('APP_CRASH', (error, context) => {
      console.error('应用崩溃:', error)
      
      // 尝试恢复应用状态
      this.recoverAppState()
      
      // 显示用户友好的错误信息
      this.showUserFriendlyError('应用遇到问题，正在尝试恢复...')
      
      return true
    })

    // 添加页面切换错误处理
    globalErrorHandler.addErrorHandler('PAGE_NAVIGATION_ERROR', (error, context) => {
      console.error('页面导航错误:', error)
      
      // 尝试回到首页
      setTimeout(() => {
        try {
          uni.reLaunch({
            url: '/pages/index/index'
          })
        } catch (navError) {
          console.error('导航到首页失败:', navError)
        }
      }, 1000)
      
      return true
    })
  }

  /**
   * 设置微信小程序特殊处理
   */
  setupMiniProgramSpecific() {
    // #ifdef MP-WEIXIN
    
    // 监听小程序显示
    if (typeof wx !== 'undefined' && wx.onAppShow) {
      wx.onAppShow(() => {
        console.log('小程序显示，检查系统状态')
        this.checkSystemHealth()
      })
    }

    // 监听小程序隐藏
    if (typeof wx !== 'undefined' && wx.onAppHide) {
      wx.onAppHide(() => {
        console.log('小程序隐藏，清理资源')
        this.cleanupResources()
      })
    }

    // 监听内存警告
    if (typeof wx !== 'undefined' && wx.onMemoryWarning) {
      wx.onMemoryWarning(() => {
        console.warn('收到内存警告，开始清理')
        this.handleMemoryWarning()
      })
    }

    // 设置小程序更新检查
    this.setupUpdateCheck()
    
    // #endif
  }

  /**
   * 设置性能监控
   */
  setupPerformanceMonitoring() {
    // 监控页面性能
    this.startPerformanceMonitoring()
    
    // 定期检查系统健康状态
    setInterval(() => {
      this.checkSystemHealth()
    }, 60000) // 每分钟检查一次
  }

  /**
   * 设置内存管理
   */
  setupMemoryManagement() {
    // 定期清理内存
    setInterval(() => {
      this.performMemoryCleanup()
    }, 300000) // 每5分钟清理一次

    // 监控内存使用
    this.startMemoryMonitoring()
  }

  /**
   * 设置小程序更新检查
   */
  setupUpdateCheck() {
    // #ifdef MP-WEIXIN
    if (typeof wx !== 'undefined' && wx.getUpdateManager) {
      const updateManager = wx.getUpdateManager()

      updateManager.onCheckForUpdate((res) => {
        console.log('检查更新结果:', res.hasUpdate)
      })

      updateManager.onUpdateReady(() => {
        uni.showModal({
          title: '更新提示',
          content: '新版本已经准备好，是否重启应用？',
          success: (res) => {
            if (res.confirm) {
              updateManager.applyUpdate()
            }
          }
        })
      })

      updateManager.onUpdateFailed(() => {
        console.error('小程序更新失败')
      })
    }
    // #endif
  }

  /**
   * 开始性能监控
   */
  startPerformanceMonitoring() {
    // 监控页面加载时间
    this.monitorPageLoadTime()
    
    // 监控API响应时间
    this.monitorApiResponseTime()
  }

  /**
   * 监控页面加载时间
   */
  monitorPageLoadTime() {
    const originalNavigateTo = uni.navigateTo
    
    uni.navigateTo = function(options) {
      const startTime = Date.now()
      
      const originalSuccess = options.success
      options.success = function(res) {
        const loadTime = Date.now() - startTime
        console.log(`页面加载时间: ${options.url} - ${loadTime}ms`)
        
        if (loadTime > 3000) {
          console.warn(`页面加载较慢: ${options.url}`)
        }
        
        if (originalSuccess) originalSuccess(res)
      }
      
      return originalNavigateTo.call(this, options)
    }
  }

  /**
   * 监控API响应时间
   */
  monitorApiResponseTime() {
    const originalRequest = uni.request
    
    uni.request = function(options) {
      const startTime = Date.now()
      
      const originalSuccess = options.success
      options.success = function(res) {
        const responseTime = Date.now() - startTime
        console.log(`API响应时间: ${options.url} - ${responseTime}ms`)
        
        if (responseTime > 5000) {
          console.warn(`API响应较慢: ${options.url}`)
        }
        
        if (originalSuccess) originalSuccess(res)
      }
      
      return originalRequest.call(this, options)
    }
  }

  /**
   * 开始内存监控
   */
  startMemoryMonitoring() {
    // #ifdef MP-WEIXIN
    if (typeof wx !== 'undefined' && wx.getPerformance) {
      setInterval(() => {
        try {
          const performance = wx.getPerformance()
          if (performance && performance.memory) {
            const memoryInfo = performance.memory
            console.log('内存使用情况:', memoryInfo)
            
            // 如果内存使用过高，触发清理
            if (memoryInfo.usedJSHeapSize > 50 * 1024 * 1024) { // 50MB
              console.warn('内存使用过高，触发清理')
              this.performMemoryCleanup()
            }
          }
        } catch (error) {
          console.error('获取内存信息失败:', error)
        }
      }, 30000) // 每30秒检查一次
    }
    // #endif
  }

  /**
   * 检查系统健康状态
   */
  checkSystemHealth() {
    const healthCheck = {
      timestamp: Date.now(),
      errorStats: globalErrorHandler.getErrorStats(),
      componentStats: lifecycleManager.getStats(),
      memoryUsage: this.getMemoryUsage()
    }

    console.log('系统健康检查:', healthCheck)

    // 如果错误率过高，触发清理
    if (healthCheck.errorStats.total > 100) {
      console.warn('错误率过高，触发系统清理')
      this.performSystemCleanup()
    }
  }

  /**
   * 获取内存使用情况
   */
  getMemoryUsage() {
    // #ifdef MP-WEIXIN
    if (typeof wx !== 'undefined' && wx.getPerformance) {
      try {
        const performance = wx.getPerformance()
        return performance.memory || {}
      } catch (error) {
        return {}
      }
    }
    // #endif
    
    return {}
  }

  /**
   * 执行内存清理
   */
  performMemoryCleanup() {
    console.log('执行内存清理')
    
    try {
      // 清理组件状态
      lifecycleManager.cleanupInactiveComponents()
      
      // 清理错误日志
      errorMonitoring.cleanupOldErrors()
      
      // 触发垃圾回收
      // #ifdef MP-WEIXIN
      if (typeof wx !== 'undefined' && wx.triggerGC) {
        wx.triggerGC()
      }
      // #endif
      
      console.log('内存清理完成')
    } catch (error) {
      console.error('内存清理失败:', error)
    }
  }

  /**
   * 执行系统清理
   */
  performSystemCleanup() {
    console.log('执行系统清理')
    
    try {
      // 重置错误统计
      globalErrorHandler.resetErrorStats()
      
      // 清理内存
      this.performMemoryCleanup()
      
      // 清理缓存
      this.clearCache()
      
      console.log('系统清理完成')
    } catch (error) {
      console.error('系统清理失败:', error)
    }
  }

  /**
   * 清理缓存
   */
  clearCache() {
    try {
      // 清理一些非关键的本地存储
      const keysToRemove = ['temp_data', 'cache_data']
      keysToRemove.forEach(key => {
        try {
          uni.removeStorageSync(key)
        } catch (error) {
          // 忽略清理失败
        }
      })
    } catch (error) {
      console.error('清理缓存失败:', error)
    }
  }

  /**
   * 处理内存警告
   */
  handleMemoryWarning() {
    console.warn('处理内存警告')
    
    // 立即执行内存清理
    this.performMemoryCleanup()
    
    // 显示用户提示
    this.showUserFriendlyError('系统内存不足，已自动清理')
  }

  /**
   * 恢复应用状态
   */
  recoverAppState() {
    console.log('尝试恢复应用状态')
    
    try {
      // 清理所有组件状态
      this.performSystemCleanup()
      
      // 重新初始化关键服务
      this.reinitializeCriticalServices()
      
    } catch (error) {
      console.error('恢复应用状态失败:', error)
    }
  }

  /**
   * 重新初始化关键服务
   */
  reinitializeCriticalServices() {
    try {
      // 重新初始化错误监控
      errorMonitoring.setEnabled(true)
      
      console.log('关键服务重新初始化完成')
    } catch (error) {
      console.error('重新初始化关键服务失败:', error)
    }
  }

  /**
   * 显示用户友好的错误信息
   * @param {string} message - 错误消息
   */
  showUserFriendlyError(message) {
    try {
      uni.showToast({
        title: message,
        icon: 'none',
        duration: 2000
      })
    } catch (error) {
      console.error('显示用户错误信息失败:', error)
    }
  }

  /**
   * 降级初始化
   */
  fallbackInit() {
    console.log('执行降级初始化')
    
    try {
      // 只初始化最基本的功能
      globalErrorHandler.init()
      
      this.isInitialized = true
      console.log('降级初始化完成')
      
    } catch (error) {
      console.error('降级初始化也失败了:', error)
    }
  }

  /**
   * 记录初始化成功
   */
  logInitSuccess() {
    const initInfo = {
      initTime: this.initEndTime - this.initStartTime,
      timestamp: this.initEndTime,
      platform: this.getPlatform(),
      version: this.getAppVersion()
    }

    console.log('应用初始化成功:', initInfo)
  }

  /**
   * 获取平台信息
   */
  getPlatform() {
    // #ifdef MP-WEIXIN
    return 'miniprogram'
    // #endif
    
    // #ifdef H5
    return 'h5'
    // #endif
    
    return 'unknown'
  }

  /**
   * 获取应用版本
   */
  getAppVersion() {
    // #ifdef MP-WEIXIN
    if (typeof wx !== 'undefined' && wx.getAccountInfoSync) {
      try {
        const accountInfo = wx.getAccountInfoSync()
        return accountInfo.miniProgram.version
      } catch (error) {
        return 'unknown'
      }
    }
    // #endif
    
    return '1.0.0'
  }

  /**
   * 获取初始化状态
   */
  getInitStatus() {
    return {
      isInitialized: this.isInitialized,
      initStartTime: this.initStartTime,
      initEndTime: this.initEndTime,
      initDuration: this.initEndTime ? this.initEndTime - this.initStartTime : null
    }
  }
}

// 创建全局实例
const appInitializer = new AppInitializer()

export default appInitializer